/**
 * 批量处理配置
 */
export const BATCH_PROCESSING_CONFIG = {
    // 并发处理数量 - 多GPU+多图处理（动态并发数）
    CONCURRENCY: 1, // 默认值，实际使用动态获取

    // 处理超时时间（毫秒）
    TIMEOUT: 300000, // 5分钟

    // 重试次数
    MAX_RETRIES: 3,

    // 重试延迟（毫秒）
    RETRY_DELAY: 1000,

    // 支持的图片格式
    SUPPORTED_FORMATS: ['.jpg', '.jpeg', '.avif', '.webp'],

    // 最大文件大小（字节）
    MAX_FILE_SIZE: 10 * 1024 * 1024, // 10MB

    // 最大批量数量 - 基于GPU服务器数量动态调整
    MAX_BATCH_SIZE: 10, // 默认值，实际基于GPU服务器数量动态计算

    // 批量下载配置 - 基于GPU服务器数量动态调整
    DOWNLOAD_BATCH_SIZE: 1, // 默认值，实际基于GPU服务器数量
    DOWNLOAD_DELAY: 1000, // 每张图片下载间隔（毫秒）
    BATCH_DELAY: 2000, // 批次间延迟（毫秒）

    // Base64编码配置 - 基于GPU服务器数量动态调整
    PREVIEW_BATCH_SIZE: 1, // 默认值，实际基于GPU服务器数量

    // 动态并发控制配置
    DYNAMIC_CONCURRENCY: {
        enabled: false,             // 禁用动态并发控制，使用配置文件
        updateInterval: 10000,      // 更新间隔(ms) - 10秒
        fallbackConcurrency: 1,     // 回退并发数（单GPU）
    }
} as const

/**
 * 获取并发数 - 使用配置文件管理
 */
export const getConcurrency = async (): Promise<number> => {
    // 使用场景4的动态并发控制
    try {
        const { getScenario4Concurrency } = await import('./concurrencyConfig');
        return await getScenario4Concurrency();
    } catch (error) {
        console.warn('读取配置文件失败，使用默认并发数:', error);
        return BATCH_PROCESSING_CONFIG.CONCURRENCY;
    }
}

/**
 * 获取静态并发数（用于兼容性）
 */
export const getStaticConcurrency = (): number => {
    return BATCH_PROCESSING_CONFIG.CONCURRENCY;
}

/**
 * 获取超时时间
 */
export const getTimeout = (): number => {
    return BATCH_PROCESSING_CONFIG.TIMEOUT
}

/**
 * 获取重试次数
 */
export const getMaxRetries = (): number => {
    return BATCH_PROCESSING_CONFIG.MAX_RETRIES
}

/**
 * 获取重试延迟
 */
export const getRetryDelay = (): number => {
    return BATCH_PROCESSING_CONFIG.RETRY_DELAY
}


/**
 * 获取下载延迟
 */
export const getDownloadDelay = (): number => {
    return BATCH_PROCESSING_CONFIG.DOWNLOAD_DELAY
}

/**
 * 获取批次延迟
 */
export const getBatchDelay = (): number => {
    return BATCH_PROCESSING_CONFIG.BATCH_DELAY
}

/**
 * 获取预览批次大小 - 基于GPU服务器数量动态调整
 */
export const getPreviewBatchSize = async (): Promise<number> => {
    try {
        const { getScenario4Concurrency } = await import('./concurrencyConfig');
        const gpuServerCount = await getScenario4Concurrency();
        // 预览批次大小等于GPU服务器数量，但最小为1
        return Math.max(1, gpuServerCount);
    } catch (error) {
        console.warn('获取动态预览批次大小失败，使用默认值:', error);
        return BATCH_PROCESSING_CONFIG.PREVIEW_BATCH_SIZE;
    }
}

/**
 * 获取下载批次大小 - 基于GPU服务器数量动态调整
 */
export const getDownloadBatchSize = async (): Promise<number> => {
    try {
        const { getScenario4Concurrency } = await import('./concurrencyConfig');
        const gpuServerCount = await getScenario4Concurrency();
        // 下载批次大小等于GPU服务器数量，但最小为1
        return Math.max(1, gpuServerCount);
    } catch (error) {
        console.warn('获取动态下载批次大小失败，使用默认值:', error);
        return BATCH_PROCESSING_CONFIG.DOWNLOAD_BATCH_SIZE;
    }
}

/**
 * 获取静态下载批次大小（用于兼容性）
 */
export const getStaticDownloadBatchSize = (): number => {
    return BATCH_PROCESSING_CONFIG.DOWNLOAD_BATCH_SIZE
}

/**
 * 获取静态预览批次大小（用于兼容性）
 */
export const getStaticPreviewBatchSize = (): number => {
    return BATCH_PROCESSING_CONFIG.PREVIEW_BATCH_SIZE
}

/**
 * 获取最大批量数量 - 基于GPU服务器数量动态调整
 */
export const getMaxBatchSize = async (): Promise<number> => {
    try {
        const { getScenario4Concurrency } = await import('./concurrencyConfig');
        const gpuServerCount = await getScenario4Concurrency();
        // 最大批量数量 = GPU服务器数量 * 5，但最小为10
        return Math.max(10, gpuServerCount * 5);
    } catch (error) {
        console.warn('获取动态最大批量数量失败，使用默认值:', error);
        return BATCH_PROCESSING_CONFIG.MAX_BATCH_SIZE;
    }
}

/**
 * 获取静态最大批量数量（用于兼容性）
 */
export const getStaticMaxBatchSize = (): number => {
    return BATCH_PROCESSING_CONFIG.MAX_BATCH_SIZE
}
